
# 内置函数示例
class stu:
    name = 'a'


def base_type():
    # (1) 取绝对值 abs
    print(f'取整数，浮点数，复数的绝对值 {abs(-3.212)}')

    """
    (2)
        divmod(a, b) 返回一个包含商和余数的元组(a // b, a % b) 
        参数说明：
        a: 数字，非复数。
        b: 数字，非复数。
        如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。
        如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。
        如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b
        """
    print("divmod = ", divmod(7, 2))  # (3, 1)
    print("divmod = ", divmod(3, 1.3))  # (2.0, 0.3999999999999999)

    # (3) hex(x) 函数用于将一个指定数字转换为 16 进制数,返回一个字符串，以 0x 开头
    # oct(x) 函数将一个整数转换成 8 进制字符串，8 进制以 0o 作为前缀表示。
    # bin() 返回一个整数 int 或者长整数 long int 的二进制表示 即 将整数转为二进制

    # (4) ascii(object) 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符
    print("ascii =", ascii('abcdef1_+=2@'))

    # (5) input()  函数接受一个标准输入数据，返回为 string  类型
    # a,b=input("请输入2个整数，按逗号分隔 :\t").split(",")
    # print(f'a+b={int(a)+int(b)}')

    # (6) int(x, base=10) 将一个字符串或数字转换为整型,base -- 进制数，默认十进制
    print(f'int类 转为整数 {int(10.1)} ')
    # "0b10"才是2进制格式，并转化为十进制数字2
    print("将二进制数据转换为十进制：", int('0b10', 2))
    print("将整数2转为二进制:", bin(2))

    # (7) str() 函数将对象转化为适于人阅读的形式,即字符串
    # (8) bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False
    # bool()，bool(0) 返回 False ， bool(1)返回 True

    # （9）eval(expression[, globals[, locals]]) 函数用来执行一个字符串表达式，并返回表达式的值
    zifu = " ['1709020230', '1707030416', '0', '0', '0']  "
    print("eval = ", type(zifu))  # 字符类型
    ls = eval(zifu)
    print("eval = ", type(ls))  # 列表类型

    # （10）exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码
    """
    exec(object[, globals[, locals]])
    object：必选参数，表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串，该字符串会先被解析为一组 Python 语句，然后再执行（除非发生语法错误）。如果 object 是一个 code 对象，那么它只是被简单的执行。
    globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
    locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与 globals 相同的值。
    """
    exec("print ('hello，tom ')")

    # ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值
    print(f'返回字符的ASCII数值 {ord("a")}')

    #（11） math.pow( x, y ) 方法返回 xy（x的y次方） 的值
    #


# 序列\基本类型相关操作方法
def inner_list():
    # (1) 转换成字典 dict
    d1 = dict(a='a', b='b', t='t')
    print(f'd1 = {d1}')
    d2 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))  # 映射函数方式来构造字典
    print(f'd2 = {d2}')
    d3 = dict([('one', 1), ('two', 2), ('three', 3)])  # 可迭代对象方式来构造字典
    print(f'd3 = {d3}')

    # (2) all(iterable) 用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False
    # 元素除了是 0、空、None、False 外都算 True

    print(f'all1 = {all([0, 1, 2, 3])}')  # 列表list，存在一个为0的元素
    print(f'all2 ={all([1, 2, 3, 4])}')  # 列表list，元素都不为空或0

    # (3) next() 返回迭代器的下一个项目。 next() 函数要和生成迭代器的 iter() 函数一起使用  详情查看list示例

    # (4) slice() 函数实现“切片对象”，主要用在切片操作函数里的参数传递
    # class slice(stop)  或 class slice(start, stop[, step])
    list1 = range(10)
    myslice = slice(5)
    print(f'# 截取 列表前5 个元素 切片后的结果= {list1[myslice]}')

    """
    (5)
    any(iterable) iterable -- 元组或列表 ，函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
    元素除了是 0、空、FALSE 外都算 TRUE
    """
    print("any() : ", any(['a', 'b', 'c', 'd']))  # # 列表list，元素都不为空或0  True
    print("any() : ", any([0, '', False]))  ## 列表list,元素全为0,'',false    False

    """
    #(6)  sorted(iterable, key=None, reverse=False) 
    iterable -- 可迭代对象。
    key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认
    """
    list1 = [1, 2, 55, 12, 233, 4, 22, 0]
    print("sorted = ", sorted(list1))  #

    # 对象列表排序
    array = [{"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"}]
    array = sorted(array, key=lambda x: x["age"])
    print("array sorted = ", array)

    # 对象列表排序2
    d1 = [{'name': 'alice', 'score': 38}, {'name': 'bob', 'score': 18}, {'name': 'darl', 'score': 28},
          {'name': 'christ', 'score': 28}]
    d1array = sorted(d1, key=lambda x: (-x['score'], x['name']))
    print("array sorted = ", d1array)

    # enumerate(sequence, [start=0]) 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
    for i, element in enumerate(list1):
        print(i, element)  # i是下标，element是元素

    # bytearray([source[, encoding[, errors]]) 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
    print("bytearray = ", bytearray([1, 2, 3]))

    # filter(function, iterable) 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换
    def is_odd(n):
        return n % 2 == 0

    # tmplist = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])   # 过滤出其中的偶数



# 关于对象的操作方法
def inner_objm():
    d1 = 2
    # （1） id() 返回对象内存地址
    print("返回对象内存地址", id(d1))

    # （2）返回对象帮助信息help(obj)
    # print(help('sys'))
    # print(help('str'))
    # print(help([1,2,3]))  # 展示list类所有信息

    # （3）min(序列) ,max(序列) 返回最小值，最大值 ，示例 省略
    # sum(序列) 方法对序列进行求和计算。 如：sum((2, 3, 4), 1) 元组计算总和后再加 1

    # （4） setattr(object, name, value) 用于设置属性值，该属性不一定是存在的。
    # getattr(object, name)
    st = stu()
    setattr(st, 'age', 11)
    print(f'name = {st.name} age={st.age} name={getattr(st, "name")} age={getattr(st, "age")}')

    # （5） dir([object]) 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
    # dir()   #  获得当前模块的属性列表
    # dir([ ])    # 查看列表的方法

    # （6）staticmethod() 静态方法，直接通过类名.方法名调用，需要使用@staticmethod 注解，参考object_simple2.py

    # （7） open() 函数，参考 inoutput_simple.py

    # （8） isinstance((object, classinfo) 函数来判断一个对象是否是一个已知的类型
    #   issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类

    # super() 函数是用于调用父类(超类)的一个方法

# exec 示例
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""


def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})


func()

if __name__ == '__main__':
    # base_type()
    inner_list()
